Summary

in_array(), array_search() and array_keys() searched a constant array haystack that contained finite-typed values (enum cases, constant scalars, whole enums, small int ranges, …) which can never be the needle, yet PHPStan reported nothing as long as at least one other value in the haystack could match. For example in_array($int, [Foo::ONE, 1, 2], true) silently kept the dead Foo::ONE entry.

This adds a rule that reports each finite-typed haystack value that can never be the needle, using the type system (Type::getConstantArrays() + Type::getFiniteTypes()) rather than the array literal AST, as requested in the issue.

Changes

• New src/Rules/Comparison/ImpossibleInArrayHaystackFiniteTypesRule.php, registered at level 4 via #[RegisteredRule(level: 4)].
  • Resolves the needle and haystack types (honoring treatPhpDocTypesAsCertain), enumerates every constant array of the haystack, and for each value type whose getFiniteTypes() is non-empty checks whether it can ever equal the needle.
  • Matching is decided with InitializerExprTypeResolver::resolveIdenticalType() (strict) / resolveEqualType() (loose), so PHP's === / == semantics are respected; an unknown (maybe) third argument requires both to be impossible.
  • For in_array(), if no value can match at all the rule stays silent so the whole-call impossibility keeps being reported once by ImpossibleCheckTypeFunctionCallRule (no double reporting).
• Regression test ImpossibleInArrayHaystackFiniteTypesRuleTest + data file data/impossible-in-array-finite-types.php.

Root cause

The existing InArrayFunctionTypeSpecifyingExtension only narrows the whole call and only produces an impossible-type error when the entire in_array() evaluates to false. A partially-dead haystack (some values can match, some finite values never can) was invisible. The fix moves the check to the value level and is driven purely by the type system, so it works for any constant-array haystack regardless of whether it comes from a literal, a variable, or a class constant.

Analogous cases probed and fixed

The bug sits on the "needle/haystack search function" axis:

• array_search() — same (needle, haystack, strict) signature — fixed (was silent). It has no companion impossible-type rule, so it reports even when the whole call is impossible.
• array_keys($array, $filter_value, $strict) — search form with the needle and haystack arguments swapped — fixed (was silent). The rule uses a per-function argument-position map.
• in_array() whole-call impossibility — already covered by ImpossibleCheckTypeFunctionCallRule; the new rule deliberately defers to it to avoid duplicate errors.

Test

ImpossibleInArrayHaystackFiniteTypesRuleTest covers, for a Foo enum:

• strict and loose in_array($int, [Foo::ONE, 1, 2]) (reports Foo::ONE, with "identical to"/"equal to" wording),
• array_search() and array_keys() equivalents,
• an enum needle narrowed to Foo::ONE with haystack [Foo::ONE, Foo::TWO] (reports the dead Foo::TWO),
• and no-error cases: everything matches, mixed needle, whole-call-impossible in_array() (handled elsewhere), non-constant haystack, and a union needle that still matches.

Fixes phpstan/phpstan#14960